if (launch_editor(d->edit_path, &d->buf, NULL)) {
                        die(_("Please supply the note contents using either -m or -F option"));
                }
-               stripspace(&d->buf, 1);
+               strbuf_stripspace(&d->buf, 1);
        }
 }
 
        if (d->buf.len)
                strbuf_addch(&d->buf, '\n');
        strbuf_addstr(&d->buf, arg);
-       stripspace(&d->buf, 0);
+       strbuf_stripspace(&d->buf, 0);
 
        d->given = 1;
        return 0;
                        die_errno(_("cannot read '%s'"), arg);
        } else if (strbuf_read_file(&d->buf, arg, 1024) < 0)
                die_errno(_("could not open or read '%s'"), arg);
-       stripspace(&d->buf, 0);
+       strbuf_stripspace(&d->buf, 0);
 
        d->given = 1;
        return 0;
                if (!c)
                        return 0;
        } else {
-               init_notes(NULL, NULL, NULL, 0);
+               init_notes(NULL, NULL, NULL, NOTES_INIT_WRITABLE);
                t = &default_notes_tree;
        }
 
-       while (strbuf_getline(&buf, stdin, '\n') != EOF) {
+       while (strbuf_getline_lf(&buf, stdin) != EOF) {
                unsigned char from_obj[20], to_obj[20];
                struct strbuf **split;
                int err;
        return ret;
 }
 
-static struct notes_tree *init_notes_check(const char *subcommand)
+static struct notes_tree *init_notes_check(const char *subcommand,
+                                          int flags)
 {
        struct notes_tree *t;
-       init_notes(NULL, NULL, NULL, 0);
+       const char *ref;
+       init_notes(NULL, NULL, NULL, flags);
        t = &default_notes_tree;
 
-       if (!starts_with(t->ref, "refs/notes/"))
+       ref = (flags & NOTES_INIT_WRITABLE) ? t->update_ref : t->ref;
+       if (!starts_with(ref, "refs/notes/"))
                die("Refusing to %s notes in %s (outside of refs/notes/)",
-                   subcommand, t->ref);
+                   subcommand, ref);
        return t;
 }
 
                usage_with_options(git_notes_list_usage, options);
        }
 
-       t = init_notes_check("list");
+       t = init_notes_check("list", 0);
        if (argc) {
                if (get_sha1(argv[0], object))
                        die(_("Failed to resolve '%s' as a valid ref."), argv[0]);
        if (get_sha1(object_ref, object))
                die(_("Failed to resolve '%s' as a valid ref."), object_ref);
 
-       t = init_notes_check("add");
+       t = init_notes_check("add", NOTES_INIT_WRITABLE);
        note = get_note(t, object);
 
        if (note) {
        if (get_sha1(object_ref, object))
                die(_("Failed to resolve '%s' as a valid ref."), object_ref);
 
-       t = init_notes_check("copy");
+       t = init_notes_check("copy", NOTES_INIT_WRITABLE);
        note = get_note(t, object);
 
        if (note) {
        if (get_sha1(object_ref, object))
                die(_("Failed to resolve '%s' as a valid ref."), object_ref);
 
-       t = init_notes_check(argv[0]);
+       t = init_notes_check(argv[0], NOTES_INIT_WRITABLE);
        note = get_note(t, object);
 
        prepare_note_data(object, &d, edit ? note : NULL);
        if (get_sha1(object_ref, object))
                die(_("Failed to resolve '%s' as a valid ref."), object_ref);
 
-       t = init_notes_check("show");
+       t = init_notes_check("show", 0);
        note = get_note(t, object);
 
        if (!note)
                die("Could not parse commit from NOTES_MERGE_PARTIAL.");
 
        if (partial->parents)
-               hashcpy(parent_sha1, partial->parents->item->object.sha1);
+               hashcpy(parent_sha1, partial->parents->item->object.oid.hash);
        else
                hashclr(parent_sha1);
 
 
        o.local_ref = default_notes_ref();
        strbuf_addstr(&remote_ref, argv[0]);
-       expand_notes_ref(&remote_ref);
+       expand_loose_notes_ref(&remote_ref);
        o.remote_ref = remote_ref.buf;
 
-       t = init_notes_check("merge");
+       t = init_notes_check("merge", NOTES_INIT_WRITABLE);
 
        if (strategy) {
                if (parse_notes_merge_strategy(strategy, &o.strategy)) {
        argc = parse_options(argc, argv, prefix, options,
                             git_notes_remove_usage, 0);
 
-       t = init_notes_check("remove");
+       t = init_notes_check("remove", NOTES_INIT_WRITABLE);
 
        if (!argc && !from_stdin) {
                retval = remove_one_note(t, "HEAD", flag);
                usage_with_options(git_notes_prune_usage, options);
        }
 
-       t = init_notes_check("prune");
+       t = init_notes_check("prune", NOTES_INIT_WRITABLE);
 
        prune_notes(t, (verbose ? NOTES_PRUNE_VERBOSE : 0) |
                (show_only ? NOTES_PRUNE_VERBOSE|NOTES_PRUNE_DRYRUN : 0) );